#pragma once
#include <iostream>
#include <pthread.h>
#include <mutex>
#include <functional>
#include <vector>
#include <unistd.h>
#include <cassert>
#include <algorithm>
#include <string>
#include <cstring>
#include <condition_variable>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <utility>
#include <unordered_map>
#include <sys/eventfd.h>
#include <thread>
#include <memory>
#include <sys/timerfd.h>
#include <typeinfo>
#include <csignal>
// 日志打印宏
#include <ctime>
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL INF
#define LOG(level, format, ...)                                                                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        if (level < LOG_LEVEL)                                                                                         \
            break;                                                                                                     \
        time_t t = time(NULL);                                                                                         \
        struct tm *ltm = localtime(&t);                                                                                \
        char tmp[32] = {0};                                                                                            \
        strftime(tmp, 31, "%H:%M:%S", ltm);                                                                            \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void *)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)
#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)
// buffer缓冲区
/*  1.实现通信套接字的用户态缓冲区
    2.保证接受数据的完整性/发送时的状态
*/
#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
public:
    Buffer() : _buffer(BUFFER_DEFAULT_SIZE),
               _read_idx(0),
               _write_idx(0)
    {
    }
    Buffer(const Buffer &tmp)
    {
        _buffer = tmp._buffer;
        _read_idx = tmp._read_idx;
        _write_idx = tmp._write_idx;
    }
    char *Begin() { return &*_buffer.begin(); }
    // 获取当前写入起始地址
    char *WritePosition()
    {
        return Begin() + _write_idx;
    }
    // 获取当前读取起始地址
    char *ReadPosition()
    {
        return Begin() + _read_idx;
    }
    // 获取写偏移之后的空间
    uint64_t TailIdlesize()
    {
        return _buffer.size() - _write_idx;
    }
    // 获取读偏移之前的空间
    uint64_t HeadIdlesize()
    {
        return _read_idx;
    }
    // 获取读取空间大小
    uint64_t ReadAblesize()
    {
        return _write_idx - _read_idx;
    }
    // 写偏移后移
    void MoveWriteOffset(uint64_t len)
    {
        assert(len <= TailIdlesize());
        _write_idx += len;
    }
    // 读偏移后移
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        assert(len <= ReadAblesize());
        _read_idx += len;
    }
    // 扩容 确保写空间充足
    void EnsureWriteSpace(uint64_t len)
    {
        if (TailIdlesize() > len)
            return;
        else if (TailIdlesize() + HeadIdlesize() >= len)
        {
            uint64_t rsz = ReadAblesize();
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
            _read_idx = 0;
            _write_idx = rsz;
        }
        else // 扩容
        {
            _buffer.resize(_write_idx + len);
        }
    }
    // 写数据
    void Write(const void *data, uint64_t len)
    {
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }

    void WriteString(const std::string &data)
    {
        return Write((void *)data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }

    void WriteBuffer(Buffer &data)
    {
        return Write((void *)data.ReadPosition(), data.ReadAblesize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAblesize());
    }

    // 读数据
    void Read(void *buffer, uint64_t len)
    {
        assert(len <= ReadAblesize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buffer);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }

    std::string ReadString(uint64_t len)
    {
        assert(len <= ReadAblesize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }
    std::string ReadAndPopString(uint64_t len)
    {
        assert(len <= ReadAblesize());
        std::string ret = ReadString(len);
        MoveReadOffset(len);
        return ret;
    }
    // 查找换行
    char *FindCRLF()
    {
        void *res = memchr(ReadPosition(), '\n', ReadAblesize());
        return (char *)res;
    }
    // 返回一行数据
    std::string Getline()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
            return "";
        return ReadString(pos - ReadPosition() + 1);
    }
    std::string GetlineAndPop()
    {
        std::string ret = Getline();
        MoveReadOffset(ret.size());
        return ret;
    }
    // 清空缓冲区
    void Clear()
    {
        _write_idx = _read_idx = 0;
    }
    ~Buffer() {}

private:
    std::vector<char> _buffer; // 缓冲区
    uint64_t _read_idx;        // 相对读偏移量
    uint64_t _write_idx;       // 相对写偏移量
};

// socket 对socket进行封装
/*  对套接字的使用更加简洁
 */
#define MAX_LISTEN 1024
class Sock
{
private:
    int _sockfd;

public:
    Sock() : _sockfd(-1) {}
    Sock(int fd) : _sockfd(fd) {}
    // 创建套接字
    bool Creat()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("Certe socket error");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET; // ipv4
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // 绑定
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("Socket Bind Address error");
            return false;
        }
        return true;
    }
    // 监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ERR_LOG("Listen Failed");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET; // ipv4
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // 绑定
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("Connect Server Failed");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            ERR_LOG("Accept new connect Failed");
            return -1;
        }
        return newfd;
    }
    // 接受数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 无数据情况下的错误
            // EINTR 阻塞被信号打断
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ERR_LOG("Socket recv failed");
            return -1;
        }
        return ret;
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // 非阻塞接受
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ERR_LOG("Socket Send failed");
            return -1;
        }
        return ret;
    }
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        return Send(buf, len, MSG_DONTWAIT); // 非阻塞发送
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建服务器连接
    bool CreatServer(uint16_t port, const std::string &ip = "0.0.0.0", bool flag = 0)
    {
        if (Creat() == false)
            return false;
        if (flag == true)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ReuseAddress();
        return true;
    }
    // 创建客户端连接
    bool CreatClient(uint16_t port, const std::string &ip)
    {
        if (Creat() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字开启端口
    void ReuseAddress()
    {
        int opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&opt, sizeof(int));
        opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&opt, sizeof(int));
    }
    // 设置套接字为非阻塞
    void NonBlock()
    {
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
    int Fd() { return _sockfd; }
    ~Sock()
    {
        Close();
    }
};

// channer 对IO事件进行管理
/*  描述符的监控事件在用户态更容易维护
 */
class EventLoop;
class Poller;
class Channel
{
private:
    int _fd;
    uint32_t _event;  // 需要监控的事件
    uint32_t _revent; // 触发事件
    // Poller *_poller;
    EventLoop *_loop;
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件
    EventCallback _write_callback; // 可写事件
    EventCallback _error_callback; // 错误事件
    EventCallback _close_callback; // 连接断开
    EventCallback _event_callback; // 事件触发
public:
    Channel(EventLoop *loop, int fd) : _fd(fd),
                                       _event(0),
                                       _revent(0),
                                       _loop(loop) //_poller(poller)
    {
    }
    int Fd() { return _fd; }
    void SetRevent(uint32_t events) { _revent = events; }
    uint32_t GetEvent()
    {
        return _event;
    }
    void SetReadCallback(const EventCallback &cb)
    {
        _read_callback = cb;
    }
    void SetWriteCallback(const EventCallback &cb)
    {
        _write_callback = cb;
    }
    void SetErrorCallback(const EventCallback &cb)
    {
        _error_callback = cb;
    }
    void SetCloseCallback(const EventCallback &cb)
    {
        _close_callback = cb;
    }
    void SetEventCallback(const EventCallback &cb)
    {
        _event_callback = cb;
    }

    // 是否可读
    bool ReadAble()
    {
        return (_event & EPOLLIN);
    }
    // 是否可写
    bool WriteAble()
    {
        return (_event & EPOLLOUT);
    }
    // 启动可读事件监控
    void EnableRead()
    {
        // 将可读事件添加到_event 在Eventloop模块处理
        _event |= EPOLLIN;
        Update();
    }
    // 启动可写事件监控
    void EnableWrite()
    {
        // 将可写事件添加到_event 在Eventloop模块处理
        _event |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        // 将_event中的可读事件修改   在Eventloop模块处理
        _event &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        // 将_event中的可写事件修改   在Eventloop模块处理
        _event &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void Disable()
    {
        _event = 0;
        Update();
    }
    // 解除监控
    void Remove();
    void Update();

    // 事件处理
    void HandleEvent()
    {
        if ((_revent & EPOLLIN) || (_revent & EPOLLRDHUP) || (_revent & EPOLLPRI))
        {
            // if (_event_callback) _event_callback();
            if (_read_callback)
                _read_callback();
        }
        // 连接有可能断开的操作单独处理
        if (_revent & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        else if (_revent & EPOLLERR)
        {
            if (_error_callback)
                _error_callback();
        }
        else if (_revent & EPOLLHUP)
        {
            if (_close_callback)
                _close_callback();
        }
        if (_event_callback)
            _event_callback();
    }
};

// poller 对任意的描述符进行IO事件监控（对epoll进行封装）
/*  对描述符进行时间监控的操作更加简单
 */
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private:
    // 对epoll直接操作
    void Update(Channel *channel, int op)
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->GetEvent();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ERR_LOG("Epoll Failed");
        }
        return;
    }
    // 判断是否已经添加监控
    bool HacChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }
        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            ERR_LOG("Epoll Creat Error");
            abort();
        }
    }
    // 添加（修改）监控
    void UpdateEvent(Channel *channel)
    {
        bool ret = HacChannel(channel);
        if (ret == false)
        {
            _channels.insert(std::make_pair(channel->Fd(), channel));
            Update(channel, EPOLL_CTL_ADD);
            return;
        }
        Update(channel, EPOLL_CTL_MOD);
    }
    // 删除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 启动监控
    void Poll(std::vector<Channel *> *active)
    {
        int ret = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("Epoll Wait Error %s\n", strerror(errno));
            abort();
        }
        for (int i = 0; i < ret; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetRevent(_evs[i].events);
            active->push_back(it->second);
        }
        return;
    }
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;

class TimeTask
{
private:
    uint64_t _id;      // 任务ID
    uint32_t _timeout; // 超时时间
    bool _canceled;    // 判断任务是否被取消
    TaskFunc _task;    // 具体任务
    ReleaseFunc _releace;

public:
    TimeTask(uint64_t id, uint32_t timeout, const TaskFunc &cb) : _id(id),
                                                                  _timeout(timeout),
                                                                  _canceled(false),
                                                                  _task(cb)
    {
    }
    ~TimeTask()
    {
        if (_canceled == false)
            _task();
        _releace();
    }
    void SetRelease(const ReleaseFunc &cb) { _releace = cb; }
    uint32_t GetTimeout() { return _timeout; }
    void cancel()
    {
        _canceled = true;
    }
};

// 时间轮
class TimerWheel
{
private:
    using PtrTask = std::shared_ptr<TimeTask>;
    using WeakTask = std::weak_ptr<TimeTask>;
    int _capacity; // 容量
    int _tick;     // 秒
    std::vector<std::vector<PtrTask>> _Wheel;
    std::unordered_map<uint64_t, WeakTask> _times;

    EventLoop *_loop;
    int _timerfd;
    std::unique_ptr<Channel> _time_channel;

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _times.find(id);
        if (it != _times.end())
            _times.erase(it);
    }
    static int CreatTimerFd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("Timerfd_creat Failed");
            abort();
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            ERR_LOG("Timefd Read Failed");
            abort();
        }
        return times;
    }
    // 每秒执行一次
    void RunTimeTask()
    {
        _tick = (_tick + 1) % _capacity;
        _Wheel[_tick].clear();
    }
    void Ontime()
    {
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
            RunTimeTask();
    }
    void TimerAddInloop(uint64_t id, uint32_t timeout, const TaskFunc &cb)
    {
        PtrTask pt(new TimeTask(id, timeout, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + timeout) % _capacity;
        _Wheel[pos].push_back(pt);
        _times[id] = WeakTask(pt);
    }
    void TimerRefreshInloop(uint64_t id)
    {
        auto it = _times.find(id);
        if (it == _times.end())
            return;
        PtrTask pt = it->second.lock();
        int delay = pt->GetTimeout();
        int pos = (_tick + delay) % _capacity;
        _Wheel[pos].push_back(pt);
    }
    void TimerCancelInloop(uint64_t id)
    {
        auto it = _times.find(id);
        if (it == _times.end())
            return;
        PtrTask pt = it->second.lock();
        if (pt)
            pt->cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(60),
                                  _tick(0),
                                  _Wheel(_capacity),
                                  _loop(loop),
                                  _timerfd(CreatTimerFd()),
                                  _time_channel(new Channel(_loop, _timerfd))
    {
        _time_channel->SetReadCallback(std::bind(&TimerWheel::Ontime, this));
        _time_channel->EnableRead();
    }
    // 添加任务
    void TimerAdd(uint64_t id, uint32_t timeout, const TaskFunc &cb);
    // 刷新/延时
    void TimerRefresh(uint64_t id);
    // 取消
    void TimerCancel(uint64_t id);
    // 函数存在新线程安全，只能在主模块内调用
    bool HasTimer(uint64_t id)
    {
        auto it = _times.find(id);
        if (it == _times.end())
            return false;
        return true;
    }
};

// eventloop 进行事件监控管理模块（reactor）
/*
    每一个connection连接，都会绑定一个EventLoop模块和线程，即
        对于外界连接的所有操作，都要放在同一个线程中进行
*/
class EventLoop
{
private:
    using Functor = std::function<void()>;
    Poller _poller;
    std::thread::id _thread_id; // 线程id
    int _event_fd;              // 任务id
    std::unique_ptr<Channel> _event_channel;
    std::vector<Functor> _task; //  任务池
    std::mutex _mutex;          // 保证任务池的线程安全
    TimerWheel _timewheel;

public:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _task.swap(functor);
        }
        for (auto &fun : functor)
            fun();
        return;
    }
    static int CreatEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("Creat Eventfd Failed");
            abort();
        }
        return efd;
    }
    void ReadEventFd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            ERR_LOG("Read Eventfd Failed");
            abort();
        }
        return;
    }
    // 唤醒
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("Write Eventfd Failed");
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreatEventFd()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timewheel(this)

    {
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));
        _event_channel->EnableRead();
    }
    // 启动
    void Start()
    {
        while (1)
        {
            // 监控
            std::vector<Channel *> active;
            _poller.Poll(&active);
            // 处理
            for (auto &channel : active)
            {
                channel->HandleEvent();
            }
            // 执行
            RunAllTask();
        }
    }
    // 当前线程是否对应
    bool IsInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }
    void AssertInloop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }
    // 任务是否在当前线程中 是执行 不是就压入队列
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将操作添加到任务池中
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _task.push_back(cb);
        }
        // 避免阻塞
        WeakUpEventFd();
    }
    // 修改事件监控
    void UpdateEvent(Channel *channel)
    {
        return _poller.UpdateEvent(channel);
    }
    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        return _poller.RemoveEvent(channel);
    }

    void AddTimer(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        return _timewheel.TimerAdd(id, delay, cb);
    }
    void TimerRefresh(uint64_t id)
    {
        return _timewheel.TimerRefresh(id);
    }
    void TimerCancel(uint64_t id)
    {
        return _timewheel.TimerCancel(id);
    }
    bool HasTimer(uint64_t id)
    {
        return _timewheel.HasTimer(id);
    }
};
class LoopThread
{
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLoop指针变量，这个对象需要在线程内实例化
    std::thread _thread;           // EventLoop对应的线程
private:
    /*实例化 EventLoop 对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能*/
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    /*创建线程，设定线程入口函数*/
    LoopThread() : _loop(NULL), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    /*返回当前线程关联的EventLoop对象指针*/
    EventLoop *GetLoop()
    {
        EventLoop *loop = NULL;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _cond.wait(lock, [&]()
                       { return _loop != NULL; }); // loop为NULL就一直阻塞
            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool
{
private:
    int _thread_count;
    int _next_idx;
    EventLoop *_baseloop;
    std::vector<LoopThread *> _threads;
    std::vector<EventLoop *> _loops;

public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _next_idx(0), _baseloop(baseloop) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
        return;
    }
    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
        {
            return _baseloop;
        }
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        virtual const std::type_info &type() { return typeid(T); }
        virtual holder *clone() { return new placeholder(_val); }
        ~placeholder() {}
        T _val;
    };
    holder *_content;

public:
    Any() : _content(NULL) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : NULL) {}
    ~Any() { delete _content; }
    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    template <class T>
    T *get()
    {
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }

    template <class T>
    Any &operator=(const T &val)
    {
        // 使用临时对象进行交换
        Any(val).swap(*this);
        return *this;
    }

    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};
// connection 对通信连接进行管理
/*
管理套接字
连接事件的处理
缓冲区管理
协议上下文管理
*/
class Connection;
// DISCONECTED -- 连接关闭状态；   CONNECTING -- 连接建立成功-待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；  DISCONNECTING -- 待关闭状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id;   //定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
    EventLoop *_loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接状态
    Sock _socket;                  // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区---存放从socket中读取到的数据
    Buffer _out_buffer;            // 输出缓冲区---存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
    /*换句话说，这几个回调都是组件使用者使用的*/
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
    /*五个channel的事件回调函数*/
    // 描述符可读事件触发后调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    void HandleRead()
    {
        // 1. 接收socket的数据，放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0)
        {
            // 出错了,不能直接关闭连接
            return ShutdownInLoop();
        }
        // 这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
        // 将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);
        // 2. 调用message_callback进行业务处理
        if (_in_buffer.ReadAblesize() > 0)
        {
            // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符可写事件触发后调用的函数，将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        //_out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAblesize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了，
            if (_in_buffer.ReadAblesize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release(); // 这时候就是实际的关闭释放操作了。
        }
        _out_buffer.MoveReadOffset(ret); // 千万不要忘了，将读偏移向后移动
        if (_out_buffer.ReadAblesize() == 0)
        {
            _channel.DisableWrite(); // 没有数据待发送了，关闭写事件监控
            // 如果当前是连接待关闭状态，则有数据，发送完数据释放连接，没有数据则直接释放
            if (_statu == DISCONNECTING)
            {
                return Release();
            }
        }
        return;
    }
    // 描述符触发挂断事件
    void HandleClose()
    {
        /*一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接*/
        if (_in_buffer.ReadAblesize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符触发出错事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务；  2. 调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback)
        {
            _event_callback(shared_from_this());
        }
    }
    // 连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
    void EstablishedInLoop()
    {
        // 1. 修改连接状态；  2. 启动读事件监控；  3. 调用回调函数
        assert(_statu == CONNECTING); // 当前的状态必须一定是上层的半连接状态
        _statu = CONNECTED;           // 当前函数执行完毕，则连接进入已完成连接状态
        // 一旦启动读事件监控就有可能会立即触发读事件，如果这时候启动了非活跃连接销毁
        _channel.EnableRead();
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1. 修改连接状态，将其置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
    void SendInLoop(Buffer &buf)
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }
    // 这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
    void ShutdownInLoop()
    {
        _statu = DISCONNECTING; // 设置连接为半关闭状态
        if (_in_buffer.ReadAblesize() > 0)
        {
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么就是写入数据的时候出错关闭，要么就是没有待发送数据，直接关闭
        if (_out_buffer.ReadAblesize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        if (_out_buffer.ReadAblesize() == 0)
        {
            Release();
        }
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1. 将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2. 如果当前定时销毁任务已经存在，那就刷新延迟一下即可
        if (_loop->HasTimer(_conn_id))
        {
            return _loop->TimerRefresh(_conn_id);
        }
        // 3. 如果不存在定时销毁任务，则新增
        _loop->AddTimer(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }
    void UpgradeInLoop(const Any &context,
                       const ConnectedCallback &conn,
                       const MessageCallback &msg,
                       const ClosedCallback &closed,
                       const AnyEventCallback &event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd),
                                                                _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd),
                                                                _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }
    ~Connection() { DBG_LOG("RELEASE CONNECTION:%p", this); }
    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于CONNECTED状态
    bool Connected() { return (_statu == CONNECTED); }
    // 设置上下文--连接建立完成时进行调用
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文，返回的是指针
    Any *GetContext() { return &_context; }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }
    // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据，将数据放到发送缓冲区，启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
        // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口--并不实际关闭，需要判断有没有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }
    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议---重置上下文以及阶段性回调处理函数 -- 而是这个接口必须在EventLoop线程中立即执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                 const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _loop->AssertInloop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

// accept 对监听套接字进行管理
/* 当获取了一个socket后，封装一个connection对象进行管理

*/
class Acceptor
{
private:
    Sock _socket;     // 用于创建监听套接字
    EventLoop *_loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 用于对监听套接字进行事件管理
    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;

private:
    /*监听套接字的读事件回调处理函数---获取新连接，调用_accept_callback函数进行新连接处理*/
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            return;
        }
        if (_accept_callback)
            _accept_callback(newfd);
    }
    int CreateServer(int port)
    {
        bool ret = _socket.CreatServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

public:
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    Acceptor(EventLoop *loop, int port) : _socket(CreateServer(port)), _loop(loop),
                                          _channel(loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    void Listen() { _channel.EnableRead(); }
};

class Tcp_Server
{
private:
    uint64_t _next_id;
    int _port;
    int _timeout;
    bool _enable_inactive_release;
    EventLoop _loop;                   // 进行事件监控
    Acceptor _accept;                  // 监听套接字
    std::unordered_map<uint64_t, PtrConnection> _conns; //保存管理所有连接对应的shared_ptr对象
    LoopThreadPool _pool;              //  创建loop线程池
    using Functor = std::function<void()>;
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
void RunAfterInloop(const TaskFunc &task, int delay)
    {
        _next_id++;
        _loop.AddTimer(_next_id, delay, task);
    }
    // 创建Connection管理新连接
    void NewConnection(int fd)
    {
        _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetSrvClosedCallback(std::bind(&Tcp_Server::RemoveConnection,this,std::placeholders::_1));
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        if(_enable_inactive_release)
            conn->EnableInactiveRelease(10);
        conn->Established();
        _conns.insert(std::make_pair(_next_id,conn));
    }
    void RemoveConnectionInLoop(const PtrConnection &con){
        int id = con->Id();
        if(_conns.find(id) != _conns.end())
        {
            _conns.erase(id);
        }
    }
    // 移除连接
    void RemoveConnection(const PtrConnection &con) {
        _loop.RunInLoop(std::bind(&Tcp_Server::RemoveConnectionInLoop,this,con));
    }

    

public:
    Tcp_Server(int port) : _port(port),
                           _next_id(0),
                           _enable_inactive_release(false),
                           _accept(&_loop, port),
                           _pool(&_loop)
    {
       _accept.SetAcceptCallback(std::bind(&Tcp_Server::NewConnection,this,std::placeholders::_1));
        _accept.Listen();
    }

    // 设置线程池大小
    void SetTreadCount(int count) { return _pool.SetThreadCount(count); }
    // 设置回调函数（连接建立，消息，关闭，任意）
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }
    // 是否启动非活跃连接超时销毁
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 添加定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _loop.RunInLoop(std::bind(&Tcp_Server::RunAfterInloop, this, task, delay));
    }
    // 启动服务器
    void Start()
    {
        _pool.Create();
        return _loop.Start();
    }
};
// 解除监控
void Channel::Remove()
{
    return _loop->RemoveEvent(this);
}
void Channel::Update()
{
    return _loop->UpdateEvent(this);
}
void TimerWheel::TimerAdd(uint64_t id, uint32_t timeout, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInloop, this, id, timeout, cb));
}
// 刷新/延时
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInloop, this, id));
}
// 取消
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInloop, this, id));
}
// 忽略SIGPIPE信号，连接断开后send未发送完会抛出SIGPIPE信号，导致进程退出
class NetWork{
public:
    NetWork(){
        DBG_LOG("SIGPIPE INIT");
        signal(SIGPIPE,SIG_IGN);
    }
};
static NetWork nt;